#!/usr/bin/env node

/**
 * 金牛座API连接测试脚本
 * 
 * 此脚本用于测试与金牛座API的连接是否正常，并验证令牌是否有效
 * @author Urban Lifeline Team
 */

import axios from 'axios';
import fs from 'fs';
import path from 'path';
import minimist from 'minimist';
import ora from 'ora';
import chalk from 'chalk';
import { fileURLToPath } from 'url';

// 获取当前文件目录
const __filename = fileURLToPath(import.meta.url);
const __dirname = path.dirname(__filename);

// 解析命令行参数
const args = minimist(process.argv.slice(2));
const LOG_API = args['log-api'] || false;

// 获取配置
let config;
try {
    const configPath = path.resolve(__dirname, './env.config.js');
    // 使用动态导入
    const configModule = await import(configPath);
    config = configModule.default;
} catch (error) {
    console.error(chalk.red('错误: 无法加载环境配置文件'), error.message);
    process.exit(1);
}

// 创建日志目录
const logDir = path.join(__dirname, 'logs');
if (LOG_API && !fs.existsSync(logDir)) {
    fs.mkdirSync(logDir);
}

// 记录API日志
function logApiRequest(method, url, data = null, response = null, error = null) {
    if (!LOG_API) return;

    const timestamp = new Date().toISOString();
    const logFile = path.join(logDir, `api_${new Date().toISOString().slice(0, 10)}.log`);

    let logEntry = `[${timestamp}] ${method} ${url}\n`;

    if (data) {
        logEntry += `请求数据: ${JSON.stringify(data, null, 2)}\n`;
    }

    if (response) {
        logEntry += `响应状态: ${response.status}\n`;
        logEntry += `响应数据: ${JSON.stringify(response.data, null, 2)}\n`;
    }

    if (error) {
        logEntry += `错误: ${error.message}\n`;
        if (error.response) {
            logEntry += `响应状态: ${error.response.status}\n`;
            logEntry += `响应数据: ${JSON.stringify(error.response.data, null, 2)}\n`;
        }
    }

    logEntry += '----------------------------------------\n\n';

    fs.appendFileSync(logFile, logEntry);
}

/**
 * 测试API连接并验证令牌
 */
async function testApiConnection() {
    const spinner = ora('正在测试API连接和令牌有效性...').start();

    try {
        const baseURL = config.AUTO_API_BASE_URL;
        const apiUrl = `${baseURL}/autoapi/auto.system.api/userInfo`;

        // 从文件中读取token
        const tokenPath = path.resolve(__dirname, './token.json');
        let token;

        if (fs.existsSync(tokenPath)) {
            const tokenData = JSON.parse(fs.readFileSync(tokenPath, 'utf8'));
            token = tokenData.token;
        } else {
            spinner.fail(chalk.red('错误: 找不到令牌文件，请先执行登录或刷新令牌'));
            process.exit(1);
        }

        // 发起请求验证令牌
        const response = await axios({
            method: 'post',
            url: apiUrl,
            headers: {
                'Content-Type': 'application/json',
                'Authorization': `Bearer ${token}`
            },
            data: {}
        });

        // 记录API请求日志
        logApiRequest('POST', apiUrl, {}, response);

        // 检查响应
        if (response.data && response.data.success) {
            const userInfo = response.data.data;
            spinner.succeed(chalk.green('API连接和令牌验证成功!'));

            console.log(chalk.blue('\n用户信息:'));
            console.log(`  用户名: ${chalk.yellow(userInfo.username)}`);
            console.log(`  姓名: ${chalk.yellow(userInfo.name)}`);
            console.log(`  角色: ${chalk.yellow(userInfo.roles ? userInfo.roles.join(', ') : '-')}`);

            return true;
        } else {
            spinner.fail(chalk.red(`令牌验证失败: ${response.data.message || '未知错误'}`));
            return false;
        }
    } catch (error) {
        logApiRequest('POST', `${config.AUTO_API_BASE_URL}/autoapi/auto.system.api/userInfo`, {}, null, error);

        spinner.fail(chalk.red('API连接测试失败'));

        if (error.response) {
            console.error(`状态码: ${error.response.status}`);
            console.error(`错误信息: ${JSON.stringify(error.response.data, null, 2)}`);
        } else if (error.request) {
            console.error('无法连接到服务器，请检查网络连接或API地址是否正确');
        } else {
            console.error(`错误: ${error.message}`);
        }

        return false;
    }
}

// 执行测试
testApiConnection()
    .then(success => {
        process.exit(success ? 0 : 1);
    })
    .catch(error => {
        console.error(chalk.red('执行测试时发生错误:'), error);
        process.exit(1);
    }); 